package dsl

import ast.expr.SqlBinaryOperator
import query.select.SelectQuery
import java.util.*

/**
 * Number类型扩展运算符：+，用于数值+表达式类型
 * 例如：1 + count() 或 1.plus(count())
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.plus(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.ADD, query)
}

/**
 * Number类型扩展运算符：+，用于数值+子查询
 * 例如：1 + (Select() select count() from Table) 或 1.plus(Select() select count() from Table)
 * @receiver Number 数值
 * @param query SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.plus(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.ADD, QuerySub(query))
}

/**
 * SelectQuery类型扩展运算符：+，用于子查询+数值
 * 例如：(Select() select count() from Table) + 1 或 (Select() select count() from Table).plus(1)
 * @receiver SelectQuery 子查询
 * @param number Number 数值
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.plus(number: Number): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.ADD, const(number))
}

/**
 * SelectQuery类型扩展运算符：+，用于子查询+表达式类型
 * 例如：(Select() select count() from Table) + count() 或 (Select() select count() from Table).plus(count())
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.plus(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.ADD, query)
}

/**
 * Number类型扩展运算符：-，用于数值-表达式类型
 * 例如：1 - count() 或 1.minus(count())
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.minus(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.SUB, query)
}

/**
 * Number类型扩展运算符：-，用于数值-子查询
 * 例如：1 - (Select() select count() from Table) 或 1.minus(Select() select count() from Table)
 * @receiver Number 数值
 * @param query SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.minus(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.SUB, QuerySub(query))
}

/**
 * SelectQuery类型扩展运算符：-，用于子查询+-数值
 * 例如：(Select() select count() from Table) - 1 或 (Select() select count() from Table).minus(1)
 * @receiver SelectQuery 子查询
 * @param number Number 数值
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.minus(number: Number): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.SUB, const(number))
}

/**
 * SelectQuery类型扩展运算符：-，用于子查询-表达式类型
 * 例如：(Select() select count() from Table) - count() 或 (Select() select count() from Table).minus(count())
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.minus(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.SUB, query)
}

/**
 * Number类型扩展运算符：*，用于数值*表达式类型
 * 例如：1 * count() 或 1.times(count())
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.times(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.MUL, query)
}

/**
 * Number类型扩展运算符：*，用于数值*子查询
 * 例如：1 * (Select() select count() from Table) 或 1.times(Select() select count() from Table)
 * @receiver Number 数值
 * @param query SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.times(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.MUL, QuerySub(query))
}

/**
 * SelectQuery类型扩展运算符：*，用于子查询+数值
 * 例如：(Select() select count() from Table) * 1 或 (Select() select count() from Table).times(1)
 * @receiver SelectQuery 子查询
 * @param number Number 数值
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.times(number: Number): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.MUL, const(number))
}

/**
 * SelectQuery类型扩展运算符：*，用于子查询*表达式类型
 * 例如：(Select() select count() from Table) * count() 或 (Select() select count() from Table).times(count())
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.times(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.MUL, query)
}

/**
 * Number类型扩展运算符：/，用于数值/表达式类型
 * 例如：1 / count() 或 1.div(count())
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.div(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.DIV, query)
}

/**
 * Number类型扩展运算符：/，用于数值/子查询
 * 例如：1 / (Select() select count() from Table) 或 1.div(Select() select count() from Table)
 * @receiver Number 数值
 * @param query SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.div(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.DIV, QuerySub(query))
}

/**
 * SelectQuery类型扩展运算符：/，用于子查询/数值
 * 例如：(Select() select count() from Table) / 1 或 (Select() select count() from Table).div(1)
 * @receiver SelectQuery 子查询
 * @param number Number 数值
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.div(number: Number): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.DIV, const(number))
}

/**
 * SelectQuery类型扩展运算符：/，用于子查询/表达式类型
 * 例如：(Select() select count() from Table) / count() 或 (Select() select count() from Table).div(count())
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.div(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.DIV, query)
}

/**
 * Number类型扩展运算符：%，用于数值%表达式类型
 * 例如：1 % count() 或 1.rem(count())
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.rem(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.MOD, query)
}

/**
 * Number类型扩展运算符：%，用于数值%子查询
 * 例如：1 % (Select() select count() from Table) 或 1.rem(Select() select count() from Table)
 * @receiver Number 数值
 * @param query SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
operator fun Number.rem(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.MOD, QuerySub(query))
}

/**
 * SelectQuery类型扩展运算符：%，用于子查询%数值
 * 例如：(Select() select count() from Table) % 1 或 (Select() select count() from Table).rem(1)
 * @receiver SelectQuery 子查询
 * @param number Number 数值
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.rem(number: Number): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.MOD, const(number))
}

/**
 * SelectQuery类型扩展运算符：%，用于子查询%表达式类型
 * 例如：(Select() select count() from Table) % count() 或 (Select() select count() from Table).rem(count())
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
operator fun SelectQuery.rem(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.MOD, query)
}

/**
 * Number类型扩展函数，用于生成=表达式
 * 例如：1 eq column("c1") 或 1.eq(column("c1"))
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.eq(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, query)
}

/**
 * Number类型扩展函数，用于生成=表达式
 * 例如：1 eq 1 或 1.eq(1)
 * @receiver Number 数值
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Number.eq(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, const(query))
}

/**
 * Number类型扩展函数，用于生成=表达式（对子查询）
 * 例如：1 eq (Select() from "xx")
 * @receiver Number 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.eq(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, QuerySub(query))
}

/**
 * String类型扩展函数，用于生成=表达式
 * 例如："1" eq column("c1") 或 "1".eq(column("c1"))
 * @receiver String 字符串
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun String.eq(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, query)
}

/**
 * String类型扩展函数，用于生成=表达式
 * 例如："1" eq "1" 或 "1".eq("1")
 * @receiver String 字符串
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> String.eq(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, const(query))
}

/**
 * String类型扩展函数，用于生成=表达式（对子查询）
 * 例如："1" eq (Select() from "xx")
 * @receiver String 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun String.eq(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, QuerySub(query))
}

/**
 * Date类型扩展函数，用于生成=表达式
 * 例如：Date() eq column("c1") 或 Date().eq(column("c1"))
 * @receiver Date 时间
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.eq(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, query)
}

/**
 * Date类型扩展函数，用于生成=表达式
 * 例如：Date() eq Date() 或 Date().eq(Date())
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Date.eq(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, const(query))
}

/**
 * Date类型扩展函数，用于生成=表达式（对子查询）
 * 例如：Date() eq (Select() from "xx")
 * @receiver Date 时间
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.eq(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, QuerySub(query))
}

/**
 * Boolean类型扩展函数，用于生成=表达式
 * 例如：true eq column("c1") 或 true.eq(column("c1"))
 * @receiver Boolean 布尔值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.eq(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, query)
}

/**
 * Boolean类型扩展函数，用于生成=表达式
 * 例如：true eq true 或 true.eq(true)
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Boolean.eq(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, const(query))
}

/**
 * Boolean类型扩展函数，用于生成=表达式（对子查询）
 * 例如：true eq (Select() from "xx")
 * @receiver Boolean 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.eq(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.EQ, QuerySub(query))
}

/**
 * SelectQuery类型扩展函数，用于生成=表达式
 * 例如：(Select() from Table) eq column("c1") 或 (Select() from Table).eq(column("c1"))
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.eq(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.EQ, query)
}

/**
 * SelectQuery类型扩展函数，用于生成=表达式
 * 例如：(Select() from Table) eq 1 或 (Select() from Table).eq(1)
 * @receiver SelectQuery 子查询
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> SelectQuery.eq(query: T): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.EQ, const(query))
}

/**
 * SelectQuery类型扩展函数，用于生成=表达式（对子查询）
 * 例如：(Select() from "xx") eq (Select() from "xx")
 * @receiver SelectQuery 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.eq(query: SelectQuery): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.EQ, QuerySub(query))
}

/**
 * Number类型扩展函数，用于生成<>表达式
 * 例如：1 ne column("c1") 或 1.ne(column("c1"))
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.ne(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, query)
}

/**
 * Number类型扩展函数，用于生成<>表达式
 * 例如：1 ne 1 或 1.ne(1)
 * @receiver Number 数值
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Number.ne(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, const(query))
}

/**
 * Number类型扩展函数，用于生成<>表达式（对子查询）
 * 例如：1 ne (Select() from "xx")
 * @receiver Number 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.ne(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, QuerySub(query))
}

/**
 * String类型扩展函数，用于生成<>表达式
 * 例如："1" ne column("c1") 或 "1".ne(column("c1"))
 * @receiver String 字符串
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun String.ne(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, query)
}

/**
 * String类型扩展函数，用于生成<>表达式
 * 例如："1" ne "1" 或 "1".ne("1")
 * @receiver String 字符串
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> String.ne(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, const(query))
}

/**
 * String类型扩展函数，用于生成<>表达式（对子查询）
 * 例如："1" ne (Select() from "xx")
 * @receiver String 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun String.ne(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, QuerySub(query))
}

/**
 * Date类型扩展函数，用于生成<>表达式
 * 例如：Date() ne column("c1") 或 Date().ne(column("c1"))
 * @receiver Date 时间
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.ne(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, query)
}

/**
 * Date类型扩展函数，用于生成<>表达式
 * 例如：Date() ne Date() 或 Date().ne(Date())
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Date.ne(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, const(query))
}

/**
 * Date类型扩展函数，用于生成<>表达式（对子查询）
 * 例如：Date() ne (Select() from "xx")
 * @receiver Date 时间
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.ne(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, QuerySub(query))
}

/**
 * Boolean类型扩展函数，用于生成<>表达式
 * 例如：true ne column("c1") 或 true.ne(column("c1"))
 * @receiver Boolean 布尔值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.ne(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, query)
}

/**
 * Boolean类型扩展函数，用于生成<>表达式
 * 例如：true ne true 或 true.ne(true)
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Boolean.ne(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, const(query))
}

/**
 * Boolean类型扩展函数，用于生成<>表达式（对子查询）
 * 例如：true ne (Select() from "xx")
 * @receiver Boolean 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.ne(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.NE, QuerySub(query))
}

/**
 * SelectQuery类型扩展函数，用于生成<>表达式
 * 例如：(Select() from Table) ne column("c1") 或 (Select() from Table).ne(column("c1"))
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.ne(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.NE, query)
}

/**
 * SelectQuery类型扩展函数，用于生成<>表达式
 * 例如：(Select() from Table) ne 1 或 (Select() from Table).ne(1)
 * @receiver SelectQuery 子查询
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> SelectQuery.ne(query: T): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.NE, const(query))
}

/**
 * SelectQuery类型扩展函数，用于生成<>表达式（对子查询）
 * 例如：(Select() from "xx") ne (Select() from "xx")
 * @receiver SelectQuery 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.ne(query: SelectQuery): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.NE, QuerySub(query))
}

/**
 * Number类型扩展函数，用于生成>表达式
 * 例如：1 gt column("c1") 或 1.gt(column("c1"))
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.gt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, query)
}

/**
 * Number类型扩展函数，用于生成>表达式
 * 例如：1 gt 1 或 1.gt(1)
 * @receiver Number 数值
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Number.gt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, const(query))
}

/**
 * Number类型扩展函数，用于生成>表达式（对子查询）
 * 例如：1 gt (Select() from "xx")
 * @receiver Number 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.gt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, QuerySub(query))
}

/**
 * String类型扩展函数，用于生成>表达式
 * 例如："1" gt column("c1") 或 "1".gt(column("c1"))
 * @receiver String 字符串
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun String.gt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, query)
}

/**
 * String类型扩展函数，用于生成>表达式
 * 例如："1" gt "1" 或 "1".gt("1")
 * @receiver String 字符串
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> String.gt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, const(query))
}

/**
 * String类型扩展函数，用于生成>表达式（对子查询）
 * 例如："1" gt (Select() from "xx")
 * @receiver String 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun String.gt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, QuerySub(query))
}

/**
 * Date类型扩展函数，用于生成>表达式
 * 例如：Date() gt column("c1") 或 Date().gt(column("c1"))
 * @receiver Date 时间
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.gt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, query)
}

/**
 * Date类型扩展函数，用于生成>表达式
 * 例如：Date() gt Date() 或 Date().gt(Date())
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Date.gt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, const(query))
}

/**
 * Date类型扩展函数，用于生成>表达式（对子查询）
 * 例如：Date() gt (Select() from "xx")
 * @receiver Date 时间
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.gt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, QuerySub(query))
}

/**
 * Boolean类型扩展函数，用于生成>表达式
 * 例如：true gt column("c1") 或 true.gt(column("c1"))
 * @receiver Boolean 布尔值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.gt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, query)
}

/**
 * Boolean类型扩展函数，用于生成>表达式
 * 例如：true gt true 或 true.gt(true)
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Boolean.gt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, const(query))
}

/**
 * Boolean类型扩展函数，用于生成>表达式（对子查询）
 * 例如：true gt (Select() from "xx")
 * @receiver Boolean 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.gt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GT, QuerySub(query))
}

/**
 * SelectQuery类型扩展函数，用于生成>表达式
 * 例如：(Select() from Table) gt column("c1") 或 (Select() from Table).gt(column("c1"))
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.gt(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.GT, query)
}

/**
 * SelectQuery类型扩展函数，用于生成>表达式
 * 例如：(Select() from Table) gt 1 或 (Select() from Table).gt(1)
 * @receiver SelectQuery 子查询
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> SelectQuery.gt(query: T): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.GT, const(query))
}

/**
 * SelectQuery类型扩展函数，用于生成>表达式（对子查询）
 * 例如：(Select() from "xx") gt (Select() from "xx")
 * @receiver SelectQuery 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.gt(query: SelectQuery): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.GT, QuerySub(query))
}

/**
 * Number类型扩展函数，用于生成>=表达式
 * 例如：1 ge column("c1") 或 1.ge(column("c1"))
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.ge(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, query)
}

/**
 * Number类型扩展函数，用于生成>=表达式
 * 例如：1 ge 1 或 1.ge(1)
 * @receiver Number 数值
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Number.ge(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, const(query))
}

/**
 * Number类型扩展函数，用于生成>=表达式（对子查询）
 * 例如：1 ge (Select() from "xx")
 * @receiver Number 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.ge(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, QuerySub(query))
}

/**
 * String类型扩展函数，用于生成>=表达式
 * 例如："1" ge column("c1") 或 "1".ge(column("c1"))
 * @receiver String 字符串
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun String.ge(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, query)
}

/**
 * String类型扩展函数，用于生成>=表达式
 * 例如："1" ge "1" 或 "1".ge("1")
 * @receiver String 字符串
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> String.ge(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, const(query))
}

/**
 * String类型扩展函数，用于生成>=表达式（对子查询）
 * 例如："1" ge (Select() from "xx")
 * @receiver String 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun String.ge(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, QuerySub(query))
}

/**
 * Date类型扩展函数，用于生成>=表达式
 * 例如：Date() ge column("c1") 或 Date().ge(column("c1"))
 * @receiver Date 时间
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.ge(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, query)
}

/**
 * Date类型扩展函数，用于生成>=表达式
 * 例如：Date() ge Date() 或 Date().ge(Date())
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Date.ge(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, const(query))
}

/**
 * Date类型扩展函数，用于生成>=表达式（对子查询）
 * 例如：Date() ge (Select() from "xx")
 * @receiver Date 时间
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.ge(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, QuerySub(query))
}

/**
 * Boolean类型扩展函数，用于生成>=表达式
 * 例如：true ge column("c1") 或 true.ge(column("c1"))
 * @receiver Boolean 布尔值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.ge(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, query)
}

/**
 * Boolean类型扩展函数，用于生成>=表达式
 * 例如：true ge true 或 true.ge(true)
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Boolean.ge(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, const(query))
}

/**
 * Boolean类型扩展函数，用于生成>=表达式（对子查询）
 * 例如：true ge (Select() from "xx")
 * @receiver Boolean 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.ge(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.GE, QuerySub(query))
}

/**
 * SelectQuery类型扩展函数，用于生成>=表达式
 * 例如：(Select() from Table) ge column("c1") 或 (Select() from Table).ge(column("c1"))
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.ge(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.GE, query)
}

/**
 * SelectQuery类型扩展函数，用于生成>=表达式
 * 例如：(Select() from Table) ge 1 或 (Select() from Table).ge(1)
 * @receiver SelectQuery 子查询
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> SelectQuery.ge(query: T): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.GE, const(query))
}

/**
 * SelectQuery类型扩展函数，用于生成>=表达式（对子查询）
 * 例如：(Select() from "xx") ge (Select() from "xx")
 * @receiver SelectQuery 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.ge(query: SelectQuery): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.GE, QuerySub(query))
}

/**
 * Number类型扩展函数，用于生成<表达式
 * 例如：1 lt column("c1") 或 1.lt(column("c1"))
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.lt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, query)
}

/**
 * Number类型扩展函数，用于生成<表达式
 * 例如：1 lt 1 或 1.lt(1)
 * @receiver Number 数值
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Number.lt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, const(query))
}

/**
 * Number类型扩展函数，用于生成<表达式（对子查询）
 * 例如：1 lt (Select() from "xx")
 * @receiver Number 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.lt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, QuerySub(query))
}

/**
 * String类型扩展函数，用于生成<表达式
 * 例如："1" lt column("c1") 或 "1".lt(column("c1"))
 * @receiver String 字符串
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun String.lt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, query)
}

/**
 * String类型扩展函数，用于生成<表达式
 * 例如："1" lt "1" 或 "1".lt("1")
 * @receiver String 字符串
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> String.lt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, const(query))
}

/**
 * String类型扩展函数，用于生成<表达式（对子查询）
 * 例如："1" lt (Select() from "xx")
 * @receiver String 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun String.lt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, QuerySub(query))
}

/**
 * Date类型扩展函数，用于生成<表达式
 * 例如：Date() lt column("c1") 或 Date().lt(column("c1"))
 * @receiver Date 时间
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.lt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, query)
}

/**
 * Date类型扩展函数，用于生成<表达式
 * 例如：Date() lt Date() 或 Date().lt(Date())
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Date.lt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, const(query))
}

/**
 * Date类型扩展函数，用于生成<表达式（对子查询）
 * 例如：Date() lt (Select() from "xx")
 * @receiver Date 时间
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.lt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, QuerySub(query))
}

/**
 * Boolean类型扩展函数，用于生成<表达式
 * 例如：true lt column("c1") 或 true.lt(column("c1"))
 * @receiver Boolean 布尔值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.lt(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, query)
}

/**
 * Boolean类型扩展函数，用于生成<表达式
 * 例如：true lt true 或 true.lt(true)
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Boolean.lt(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, const(query))
}

/**
 * Boolean类型扩展函数，用于生成<表达式（对子查询）
 * 例如：true lt (Select() from "xx")
 * @receiver Boolean 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.lt(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LT, QuerySub(query))
}

/**
 * SelectQuery类型扩展函数，用于生成<表达式
 * 例如：(Select() from Table) lt column("c1") 或 (Select() from Table).lt(column("c1"))
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.lt(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.LT, query)
}

/**
 * SelectQuery类型扩展函数，用于生成<表达式
 * 例如：(Select() from Table) lt 1 或 (Select() from Table).lt(1)
 * @receiver SelectQuery 子查询
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> SelectQuery.lt(query: T): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.LT, const(query))
}

/**
 * SelectQuery类型扩展函数，用于生成<表达式（对子查询）
 * 例如：(Select() from "xx") lt (Select() from "xx")
 * @receiver SelectQuery 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.lt(query: SelectQuery): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.LT, QuerySub(query))
}

/**
 * Number类型扩展函数，用于生成<=表达式
 * 例如：1 le column("c1") 或 1.le(column("c1"))
 * @receiver Number 数值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.le(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, query)
}

/**
 * Number类型扩展函数，用于生成<=表达式
 * 例如：1 le 1 或 1.le(1)
 * @receiver Number 数值
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Number.le(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, const(query))
}

/**
 * Number类型扩展函数，用于生成<=表达式（对子查询）
 * 例如：1 le (Select() from "xx")
 * @receiver Number 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Number.le(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, QuerySub(query))
}

/**
 * String类型扩展函数，用于生成<=表达式
 * 例如："1" le column("c1") 或 "1".le(column("c1"))
 * @receiver String 字符串
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun String.le(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, query)
}

/**
 * String类型扩展函数，用于生成<=表达式
 * 例如："1" le "1" 或 "1".le("1")
 * @receiver String 字符串
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> String.le(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, const(query))
}

/**
 * String类型扩展函数，用于生成<=表达式（对子查询）
 * 例如："1" le (Select() from "xx")
 * @receiver String 数值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun String.le(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, QuerySub(query))
}

/**
 * Date类型扩展函数，用于生成<=表达式
 * 例如：Date() le column("c1") 或 Date().le(column("c1"))
 * @receiver Date 时间
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.le(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, query)
}

/**
 * Date类型扩展函数，用于生成<=表达式
 * 例如：Date() le Date() 或 Date().le(Date())
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Date.le(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, const(query))
}

/**
 * Date类型扩展函数，用于生成<=表达式（对子查询）
 * 例如：Date() le (Select() from "xx")
 * @receiver Date 时间
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Date.le(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, QuerySub(query))
}

/**
 * Boolean类型扩展函数，用于生成<=表达式
 * 例如：true le column("c1") 或 true.le(column("c1"))
 * @receiver Boolean 布尔值
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.le(query: Query): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, query)
}

/**
 * Boolean类型扩展函数，用于生成<=表达式
 * 例如：true le true 或 true.le(true)
 * @receiver Date 时间
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> Boolean.le(query: T): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, const(query))
}

/**
 * Boolean类型扩展函数，用于生成<=表达式（对子查询）
 * 例如：true le (Select() from "xx")
 * @receiver Boolean 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun Boolean.le(query: SelectQuery): QueryBinary {
    return QueryBinary(const(this), SqlBinaryOperator.LE, QuerySub(query))
}

/**
 * SelectQuery类型扩展函数，用于生成<=表达式
 * 例如：(Select() from Table) le column("c1") 或 (Select() from Table).le(column("c1"))
 * @receiver SelectQuery 子查询
 * @param query Query 表达式类型
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.le(query: Query): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.LE, query)
}

/**
 * SelectQuery类型扩展函数，用于生成<=表达式
 * 例如：(Select() from Table) le 1 或 (Select() from Table).le(1)
 * @receiver SelectQuery 子查询
 * @param query T 右侧合法的类型有Number、String、Date、List、Boolean以及null
 * @return QueryBinary 二元运算表达式
 */
infix fun <T> SelectQuery.le(query: T): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.LE, const(query))
}

/**
 * SelectQuery类型扩展函数，用于生成<=表达式（对子查询）
 * 例如：(Select() from "xx") le (Select() from "xx")
 * @receiver SelectQuery 布尔值
 * @param query SelectQuery 子查询dsl
 * @return QueryBinary 二元运算表达式
 */
infix fun SelectQuery.le(query: SelectQuery): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.LE, QuerySub(query))
}

/**
 * Number类型扩展函数，用于生成IN表达式
 * 例如：1 inList listOf(column("c1"), column("c2")) 或 1.inList(listOf(column("c1"), column("c2")))
 * @receiver Number 数值
 * @param list List<T> IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> Number.inList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, false)
}

/**
 * Number类型扩展函数，用于生成IN子查询表达式
 * 例如：1 inList (Select() from Table)
 * @receiver Number 数值
 * @param subQuery SelectQuery IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun Number.inList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, false)
}

/**
 * String类型扩展函数，用于生成IN表达式
 * 例如："1" inList listOf(column("c1"), column("c2")) 或 "1".inList(listOf(column("c1"), column("c2")))
 * @receiver String 字符串
 * @param list List<T> IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> String.inList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, false)
}

/**
 * String类型扩展函数，用于生成IN子查询表达式
 * 例如："1" inList (Select() from Table)
 * @receiver String 字符串
 * @param subQuery SelectQuery IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun String.inList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, false)
}

/**
 * Date类型扩展函数，用于生成IN表达式
 * 例如：Date() inList listOf(column("c1"), column("c2")) 或 Date().inList(listOf(column("c1"), column("c2")))
 * @receiver Date 时间
 * @param list List<T> IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> Date.inList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, false)
}

/**
 * Date类型扩展函数，用于生成IN子查询表达式
 * 例如：Date() inList (Select() from Table)
 * @receiver Date 时间
 * @param subQuery SelectQuery IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun Date.inList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, false)
}

/**
 * Boolean类型扩展函数，用于生成IN表达式
 * 例如：true inList listOf(column("c1"), column("c2")) 或 true.inList(listOf(column("c1"), column("c2")))
 * @receiver Boolean 布尔值
 * @param list List<T> IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> Boolean.inList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, false)
}

/**
 * Boolean类型扩展函数，用于生成IN子查询表达式
 * 例如：true inList (Select() from Table)
 * @receiver Boolean 布尔值
 * @param subQuery SelectQuery IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun Boolean.inList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, false)
}

/**
 * SelectQuery类型扩展函数，用于生成IN表达式
 * 例如：(Select() from Table) inList listOf(column("c1"), column("c2")) 或 (Select() from Table).inList(listOf(column("c1"), column("c2")))
 * @receiver SelectQuery 子查询
 * @param list List<T> IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> SelectQuery.inList(list: List<T>): QueryInList<T> {
    return QueryInList(QuerySub(this), list, false)
}

/**
 * SelectQuery类型扩展函数，用于生成IN子查询表达式
 * 例如：(Select() from Table1) inList (Select() from Table2)
 * @receiver SelectQuery 子查询
 * @param subQuery SelectQuery IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun SelectQuery.inList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(QuerySub(this), subQuery, false)
}

/**
 * Number类型扩展函数，用于生成NOT IN表达式
 * 例如：1 notInList listOf(column("c1"), column("c2")) 或 1.notInList(listOf(column("c1"), column("c2")))
 * @receiver Number 数值
 * @param list List<T> NOT IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> Number.notInList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, true)
}

/**
 * Number类型扩展函数，用于生成NOT IN子查询表达式
 * 例如：1 notInList (Select() from Table)
 * @receiver Number 数值
 * @param subQuery SelectQuery NOT IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun Number.notInList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, true)
}

/**
 * String类型扩展函数，用于生成NOT IN表达式
 * 例如："1" notInList listOf(column("c1"), column("c2")) 或 "1".notInList(listOf(column("c1"), column("c2")))
 * @receiver String 字符串
 * @param list List<T> NOT IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> String.notInList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, true)
}

/**
 * String类型扩展函数，用于生成NOT IN子查询表达式
 * 例如："1" notInList (Select() from Table)
 * @receiver String 字符串
 * @param subQuery SelectQuery NOT IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun String.notInList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, true)
}

/**
 * Date类型扩展函数，用于生成NOT IN表达式
 * 例如：Date() notInList listOf(column("c1"), column("c2")) 或 Date().notInList(listOf(column("c1"), column("c2")))
 * @receiver Date 时间
 * @param list List<T> NOT IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> Date.notInList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, true)
}

/**
 * Date类型扩展函数，用于生成NOT IN子查询表达式
 * 例如：Date() notInList (Select() from Table)
 * @receiver Date 时间
 * @param subQuery SelectQuery NOT IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun Date.notInList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, true)
}

/**
 * Boolean类型扩展函数，用于生成NOT IN表达式
 * 例如：true notInList listOf(column("c1"), column("c2")) 或 true.notInList(listOf(column("c1"), column("c2")))
 * @receiver Boolean 布尔值
 * @param list List<T> NOT IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> Boolean.notInList(list: List<T>): QueryInList<T> {
    return QueryInList(const(this), list, true)
}

/**
 * Boolean类型扩展函数，用于生成NOT IN子查询表达式
 * 例如：true notInList (Select() from Table)
 * @receiver Boolean 布尔值
 * @param subQuery SelectQuery NOT IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun Boolean.notInList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(const(this), subQuery, true)
}

/**
 * SelectQuery类型扩展函数，用于生成NOT IN表达式
 * 例如：(Select() from Table) notInList listOf(column("c1"), column("c2")) 或 (Select() from Table).notInList(listOf(column("c1"), column("c2")))
 * @receiver SelectQuery 子查询
 * @param list List<T> NOT IN表达式列表，列表中合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @return QueryInList<T> QueryInList表达式
 */
infix fun <T> SelectQuery.notInList(list: List<T>): QueryInList<T> {
    return QueryInList(QuerySub(this), list, true)
}

/**
 * SelectQuery类型扩展函数，用于生成NOT IN子查询表达式
 * 例如：(Select() from Table1) notInList (Select() from Table2)
 * @receiver SelectQuery 子查询
 * @param subQuery SelectQuery NOT IN子查询
 * @return QueryInSubQuery QueryInSubQuery表达式
 */
infix fun SelectQuery.notInList(subQuery: SelectQuery): QueryInSubQuery {
    return QueryInSubQuery(QuerySub(this), subQuery, true)
}

/**
 * Number类型扩展函数，用于生成BETWEEN表达式
 * 例如：1.between(column("c1"), column("c2"))
 * @receiver Number 数值
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> Number.between(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end)
}

/**
 * String类型扩展函数，用于生成BETWEEN表达式
 * 例如："1".between(column("c1"), column("c2"))
 * @receiver String 字符串
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> String.between(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end)
}

/**
 * Date类型扩展函数，用于生成BETWEEN表达式
 * 例如：Date().between(column("c1"), column("c2"))
 * @receiver Date 时间
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> Date.between(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end)
}

/**
 * Boolean类型扩展函数，用于生成BETWEEN表达式
 * 例如：true.between(column("c1"), column("c2"))
 * @receiver Boolean 布尔值
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> Boolean.between(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end)
}

/**
 * SelectQuery类型扩展函数，用于生成BETWEEN表达式
 * 例如：(Select() from Table).between(column("c1"), column("c2"))
 * @receiver SelectQuery 子查询
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> SelectQuery.between(start: T, end: T): QueryBetween<T> {
    return QueryBetween(QuerySub(this), start, end)
}

/**
 * Number类型扩展函数，用于生成NOT BETWEEN表达式
 * 例如：1.notBetween(column("c1"), column("c2"))
 * @receiver Number 数值
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> Number.notBetween(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end, true)
}

/**
 * String类型扩展函数，用于生成NOT BETWEEN表达式
 * 例如："1".notBetween(column("c1"), column("c2"))
 * @receiver String 字符串
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> String.notBetween(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end, true)
}

/**
 * Date类型扩展函数，用于生成NOT BETWEEN表达式
 * 例如：Date().notBetween(column("c1"), column("c2"))
 * @receiver Date 时间
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> Date.notBetween(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end, true)
}

/**
 * Boolean类型扩展函数，用于生成NOT BETWEEN表达式
 * 例如：true.notBetween(column("c1"), column("c2"))
 * @receiver Boolean 布尔值
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> Boolean.notBetween(start: T, end: T): QueryBetween<T> {
    return QueryBetween(const(this), start, end, true)
}

/**
 * SelectQuery类型扩展函数，用于生成NOT BETWEEN表达式
 * 例如：(Select() from Table).notBetween(column("c1"), column("c2"))
 * @receiver SelectQuery 子查询
 * @param start T 起始值，合法的类型有Number、String、Date、List、Boolean以及null和Query表达式
 * @param end T 结束值，合法类型同上
 * @return QueryBetween<T> QueryBetween表达式
 */
fun <T> SelectQuery.notBetween(start: T, end: T): QueryBetween<T> {
    return QueryBetween(QuerySub(this), start, end, true)
}

/**
 * SelectQuery类型扩展函数，用于生成IS NULL表达式
 * 例如：(Select() from Table).isNull()
 * @receiver SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
fun SelectQuery.isNull(): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.IS, null)
}

/**
 * SelectQuery类型扩展函数，用于生成IS NOT NULL表达式
 * 例如：(Select() from Table).isNotNull()
 * @receiver SelectQuery 子查询
 * @return QueryBinary 二元运算表达式
 */
fun SelectQuery.isNotNull(): QueryBinary {
    return QueryBinary(QuerySub(this), SqlBinaryOperator.IS_NOT, null)
}